#include "ModuleFourier.h"

void ModuleFourier::init(QCVModuleHandlerInterface * parent)
{
	this->parent=parent;
	win=new QWidget();
  layout=new QVBoxLayout(win);

	cb_mode=new QComboBox(win);
	cb_mode->addItem("DFT Module");
	cb_mode->addItem("DFT Phase");
	cb_mode->addItem("DFT");
	cb_mode->addItem("DFT-1");

	layout->addWidget(cb_mode);
}
////////////////////////////////////////////////////////////////////////////////
void ModuleFourier::free()
{
	delete win;
}
////////////////////////////////////////////////////////////////////////////////
cv::Mat & ModuleFourier::process()
{
	//On converti l'image en niveau de gris si necessaire
	
	if(image.channels()==3)
	{
		cv::cvtColor(image,image,CV_RGB2GRAY);
	}
	if(image.depth()!=CV_32F)
	{
		image.convertTo(image,CV_32F,1.0/255.0);
	}
		
	if(cb_mode->currentIndex()==0)
	{
		//On crée une image complexe au bonnes dimensions
    cv::Mat planes[] = {image, cv::Mat::zeros(image.size(), CV_32F)};
    cv::Mat complexImg;
    merge(planes, 2, complexImg);

		//On effectue la transformée sur l'image
    cv::dft(complexImg, complexImg);

		//On sépare les parties img et reelles
    cv::split(complexImg, planes);

		//On calcule le module
    cv::magnitude(planes[0], planes[1], magnitude);

		//Puis on passe en log le module
    magnitude += cv::Scalar::all(1);
    cv::log(magnitude, magnitude);
    
		//on normalise
		cv::normalize(magnitude, magnitude, 0, 1, CV_MINMAX);


		//Enfin on réarange les cadrans
    int cx = magnitude.cols/2;
    int cy = magnitude.rows/2;
    
    cv::Mat tmp;
    cv::Mat q0(magnitude, cv::Rect(0, 0, cx, cy));
    cv::Mat q1(magnitude, cv::Rect(cx, 0, cx, cy));
    cv::Mat q2(magnitude, cv::Rect(0, cy, cx, cy));
    cv::Mat q3(magnitude, cv::Rect(cx, cy, cx, cy));
    
    q0.copyTo(tmp);
    q3.copyTo(q0);
    tmp.copyTo(q3);
    
    q1.copyTo(tmp);
    q2.copyTo(q1);
    tmp.copyTo(q2);

		return magnitude;
	}
	if(cb_mode->currentIndex()==1)
	{
	
	}		
	if(cb_mode->currentIndex()==2)
	{

		return result;		
	}
	else if(cb_mode->currentIndex()==3)
	{
		return result;		
	}
}
////////////////////////////////////////////////////////////////////////////////
void ModuleFourier::setInput(int n,const cv::Mat & m)
{
	if(n==0)
	{	
		image=m.clone();
	}
}
////////////////////////////////////////////////////////////////////////////////
QWidget* ModuleFourier::widget()
{
	return win;
}
////////////////////////////////////////////////////////////////////////////////
QString ModuleFourier::getName()
{
	return trUtf8("Transformée Fourier");
}
////////////////////////////////////////////////////////////////////////////////
int ModuleFourier::nbInputs()
{
	return 1;
}
////////////////////////////////////////////////////////////////////////////////
bool ModuleFourier::setParams(QString params)
{
	QStringList list_params=params.split(";");
		
	if(list_params.size()==1)
	{
		return true;
	}
	else
	{
		return false;
	}	
}
////////////////////////////////////////////////////////////////////////////////
QString ModuleFourier::getParams()
{
	return tr("no_param");
}

////////////////////////////////////////////////////////////////////////////////
QCVModuleInterface * ModuleFourier::clone()
{
	return new ModuleFourier;
}
////////////////////////////////////////////////////////////////////////////////
QString ModuleFourier::help(int id)
{
	if(id==-2)
	{
		return tr("Permet de calculer une TF");
	}
	else if(id==-1)
	{
		if(cb_mode->currentIndex()==2)
		{
			return tr("cplx_image");
		}
		else
		{
			return tr("image");
		}
	}
	else if(id==0)
	{
		if(cb_mode->currentIndex()==3)
		{
			return tr("cplx_image");
		}
		else
		{
			return tr("image");
		}
	}
	else
	{
		return tr("erreur");
	}
}
////////////////////////////////////////////////////////////////////////////////
Q_EXPORT_PLUGIN2(ModuleFourier_plugin,ModuleFourier);  
